﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.IO;
using Microsoft.Office.Interop.Excel;
using System.Runtime.InteropServices;
using System.Net;
using System.Security.Principal;
using System.Windows.Forms;

namespace LibraryEA
{
    public class LeitorXML
    {

        //private static void SetCredentials(WebClient webClient, string ArquivoXml)
        //{
        //    CredentialCache cache = new CredentialCache();

        //    //WindowsIdentity wi = WindowsIdentity.GetCurrent();
        //    //wi.User.

        //    cache.Add(new Uri(ArquivoXml), "Basic", new NetworkCredential("p-lliez" , "psinacor48%%"));

        //    webClient.Proxy.Credentials = cache;
        //    webClient.Credentials = cache;
        //}

        public static List<Modulo> ProcessaModulo(string ArquivoXml, string DocumentoEA, string DocumentoRTF, string DocumentoXAML, string SubModulo, string TipoConfiguracao, string AbaNegocio)
        {
            try
            {
                List<Modulo> modulos = new List<Modulo>();

                XmlDocument documento = new XmlDocument();


                documento.Load(ArquivoXml);


                //valor
                string TipoConfiguracaoNova = documento.ChildNodes[1].Attributes["Value"].Value;

                foreach(XmlNode no_modulo in documento.ChildNodes[1])
                {
                    if(no_modulo.Name == "Modulo")
                    {


                        Modulo modulo = new Modulo();
                        modulo.Nome = no_modulo.Attributes["Value"].Value;
                        modulo.Tipo = no_modulo.Name;



                        EArchitect ea = null;

                        try
                        {
                            ea = new EArchitect(DocumentoEA);
                        }
                        catch(Exception ex)
                        {
                            throw new ExceptionEA("Erro ao tentar abrir o documento. Verifique se tem permissão de escrita no mesmo", ex);
                        }

                        EA.Package pkg = null;

                        try
                        {

                            pkg = ea.AbrirModulo(modulo.Nome, SubModulo, TipoConfiguracaoNova);
                            ea.AbrirClasses(pkg);
                        }
                        catch(Exception ex)
                        {
                            if(modulo.Nome.ToLower() == "process")
                               continue;

                            throw new ExceptionEA("Erro ao tentar o módulo "+modulo.Nome+". Verifique se realmente existe o módulo nesse EA", ex);
                        }

                        modulo.Tipos = new List<Tipo>();

                        foreach(XmlNode no_tipo in no_modulo.ChildNodes)
                        {
                            Tipo tipo = new Tipo();

                            ValorDado countTotal = new ValorDado();
                            ValorDado countMetodos = new ValorDado();
                            ValorDado countPropriedades = new ValorDado();
                            ValorDado countDadosQueryEntrada = new ValorDado();
                            ValorDado countDadosQuerySaida = new ValorDado();
                            ValorDado countDadosQueryCondicional = new ValorDado();
                            ValorDado countRulesets = new ValorDado();
                            ValorDado countValidation = new ValorDado();

                            ValorDado countRegraFacil = new ValorDado();
                            ValorDado countRegraMedia = new ValorDado();
                            ValorDado countRegraDificil = new ValorDado();
                            ValorDado countRegraAvancada = new ValorDado();


                            foreach(Classe item in ea.classesEA)
                            {

                                //verifico o tipo
                                if(no_tipo.Name == "Tipo")
                                {
                                    tipo.Nome = no_tipo.Attributes["Value"].Value;


                                    if((item.tipo.ToLower() == no_tipo.Attributes["Value"].Value.ToLower()) ||
                                        (no_tipo.Attributes["Value"].Value.IndexOf("||") >= 0
                                        && (no_tipo.Attributes["Value"].Value.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[0].ToLower() == item.tipo.ToLower()
                                        || no_tipo.Attributes["Value"].Value.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[1].ToLower() == item.tipo.ToLower()))
                                        )
                                    {
                                        //count_total
                                        if(no_tipo.ChildNodes[0].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countTotal.Nome = no_tipo.ChildNodes[0].Attributes["Saida"].Value;
                                            countTotal.Valor++;
                                            countTotal.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[0].Attributes["Multiplicador"].Value);
                                        }
                                        //metodos
                                        if(no_tipo.ChildNodes[1].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countMetodos.Nome = no_tipo.ChildNodes[1].Attributes["Saida"].Value;
                                            countMetodos.Valor += item.metodos.Count;
                                            countMetodos.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[1].Attributes["Multiplicador"].Value);
                                        }
                                        //propriedades
                                        if(no_tipo.ChildNodes[2].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countPropriedades.Nome = no_tipo.ChildNodes[2].Attributes["Saida"].Value;
                                            countPropriedades.Valor += item.propriedades.Count;
                                            countPropriedades.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[2].Attributes["Multiplicador"].Value);
                                        }
                                        //dadoqueryentrada
                                        if(no_tipo.ChildNodes[3].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countDadosQueryEntrada.Nome = no_tipo.ChildNodes[3].Attributes["Saida"].Value;
                                            foreach(Classe.Metodo metodo in item.metodos)
                                            {
                                                int valor = 0;
                                                if(metodo.behavior != string.Empty)
                                                    ContarDadosQueryEntrada(ref valor, metodo.behavior);

                                                countDadosQueryEntrada.Valor += valor;
                                            }
                                            countDadosQueryEntrada.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[3].Attributes["Multiplicador"].Value);
                                        }
                                        //dadosquerysaida
                                        if(no_tipo.ChildNodes[4].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countDadosQuerySaida.Nome = no_tipo.ChildNodes[4].Attributes["Saida"].Value;
                                            foreach(Classe.Metodo metodo in item.metodos)
                                            {
                                                int valor = 0;
                                                if(metodo.behavior != string.Empty)
                                                    ContarDadosQuerySaida(ref valor, metodo.behavior);
                                                countDadosQuerySaida.Valor += valor;
                                            }
                                            countDadosQuerySaida.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[4].Attributes["Multiplicador"].Value);
                                        }
                                        //dadosquerycondicional
                                        if(no_tipo.ChildNodes[5].Attributes["Saida"].Value != string.Empty)
                                        {
                                            countDadosQueryCondicional.Nome = no_tipo.ChildNodes[5].Attributes["Saida"].Value;
                                            foreach(Classe.Metodo metodo in item.metodos)
                                            {
                                                int valor = 0;
                                                if(metodo.behavior != string.Empty)
                                                    ContarDadosQueryCondicional(ref valor, metodo.behavior);
                                                countDadosQueryCondicional.Valor += valor;
                                            }
                                            countDadosQueryCondicional.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[5].Attributes["Multiplicador"].Value);
                                        }
                                        //rulesets
                                        if(no_tipo.ChildNodes[6].Attributes["Saida"].Value != string.Empty)
                                        {

                                            foreach(Classe.Propriedade propriedade in item.propriedades)
                                            {
                                                if(propriedade.rulesets != string.Empty)
                                                {
                                                    countRulesets.Nome = no_tipo.ChildNodes[6].Attributes["Saida"].Value;
                                                    countRulesets.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[6].Attributes["Multiplicador"].Value);
                                                    if(propriedade.rulesets.IndexOf("+") >= 0)
                                                    {
                                                        countRulesets.Valor += propriedade.rulesets.Split('+').Length;
                                                    }
                                                    else
                                                    {
                                                        countRulesets.Valor++;
                                                    }
                                                }
                                            }

                                        }
                                    }
                                }
                                else if(no_tipo.Name == "MetaType")
                                {
                                    tipo.Nome = "Validações";

                                    if((item.metatype.IndexOf(no_tipo.Attributes["Value"].Value) >= 0) ||
                                    (no_tipo.Attributes["Value"].Value.IndexOf("||") >= 0
                                        && ((item.metatype.IndexOf(no_tipo.Attributes["Value"].Value.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[0].ToLower()) >= 0)
                                        || (item.metatype.IndexOf(no_tipo.Attributes["Value"].Value.Split(new string[] { "||" }, StringSplitOptions.RemoveEmptyEntries)[1].ToLower()) >= 0))))
                                    {

                                        countValidation.Nome = no_tipo.Attributes["Saida"].Value;
                                        countValidation.Multiplicador = Convert.ToInt32(no_tipo.Attributes["Multiplicador"].Value);
                                        countValidation.Valor++;

                                    }

                                }





                            }

                            if(no_tipo.Name == "Diagrama")
                            {

                                tipo.Nome = "Regras de Arquitetura";

                                foreach(Diagrama diagrama in ea.diagramasEA)
                                {
                                    if(diagrama.namespace_string.ToLower().IndexOf(no_tipo.Attributes["Value1"].Value.ToLower()) >= 0 && diagrama.namespace_string.ToLower().IndexOf(no_tipo.Attributes["Value2"].Value.ToLower()) >= 0)
                                    {
                                        switch(diagrama.tipoRegra)
                                        {
                                            case Diagrama.TipoRegra.Facil:
                                                countRegraFacil.Nome = no_tipo.ChildNodes[0].Attributes["Saida"].Value;
                                                countRegraFacil.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[0].Attributes["Multiplicador"].Value);
                                                countRegraFacil.Valor++;
                                                break;
                                            case Diagrama.TipoRegra.Medio:
                                                countRegraMedia.Nome = no_tipo.ChildNodes[1].Attributes["Saida"].Value;
                                                countRegraMedia.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[1].Attributes["Multiplicador"].Value);
                                                countRegraMedia.Valor++;
                                                break;
                                            case Diagrama.TipoRegra.Dificil:
                                                countRegraDificil.Nome = no_tipo.ChildNodes[2].Attributes["Saida"].Value;
                                                countRegraDificil.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[2].Attributes["Multiplicador"].Value);
                                                countRegraDificil.Valor++;
                                                break;
                                            case Diagrama.TipoRegra.Avancado:
                                                countRegraAvancada.Nome = no_tipo.ChildNodes[3].Attributes["Saida"].Value;
                                                countRegraAvancada.Multiplicador = Convert.ToInt32(no_tipo.ChildNodes[3].Attributes["Multiplicador"].Value);
                                                countRegraAvancada.Valor++;
                                                break;
                                            default:
                                                break;
                                        }
                                    }
                                }
                            }


                            tipo.Valores = new List<ValorDado>();
                            if(countDadosQueryCondicional.Nome != string.Empty)
                                tipo.Valores.Add(countDadosQueryCondicional);
                            if(countDadosQueryEntrada.Nome != string.Empty)
                                tipo.Valores.Add(countDadosQueryEntrada);
                            if(countDadosQuerySaida.Nome != string.Empty)
                                tipo.Valores.Add(countDadosQuerySaida);
                            if(countMetodos.Nome != string.Empty)
                                tipo.Valores.Add(countMetodos);
                            if(countPropriedades.Nome != string.Empty)
                                tipo.Valores.Add(countPropriedades);
                            if(countRulesets.Nome != string.Empty)
                                tipo.Valores.Add(countRulesets);
                            if(countTotal.Nome != string.Empty)
                                tipo.Valores.Add(countTotal);
                            if(countValidation.Nome != string.Empty)
                                tipo.Valores.Add(countValidation);


                            //regras de negocio
                            if(countRegraFacil.Nome != string.Empty)
                                tipo.Valores.Add(countRegraFacil);
                            if(countRegraMedia.Nome != string.Empty)
                                tipo.Valores.Add(countRegraMedia);
                            if(countRegraDificil.Nome != string.Empty)
                                tipo.Valores.Add(countRegraDificil);
                            if(countRegraAvancada.Nome != string.Empty)
                                tipo.Valores.Add(countRegraAvancada);


                            modulo.Tipos.Add(tipo);
                        }

                        ea.FecharEA();


                        modulos.Add(modulo);
                    }
                }

                EArchitect ea_negocio = null;
                bool novo_ea = false;
                try
                {
                    ea_negocio = new EArchitect(DocumentoEA);
                    EA.Package pkg = null;
                    pkg = ea_negocio.AbrirModulo(AbaNegocio, SubModulo);
                    ea_negocio.AbrirClasses(pkg);
                }
                catch(Exception ex)
                {
                    //Alteração para contemplar o novo modelo de EA.
                    novo_ea = true;
                    MessageBox.Show("Novo EA! Processamento utilizando a Presenter/Interface para Cálculo do Negócio", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    //throw new ExceptionEA("Erro ao tentar abrir o módulo de Negócio, Verifique o nome da pasta no EA ("+AbaNegocio+")", ex);
                }

                try
                {
                    XmlNode no_negocio = documento.GetElementsByTagName("Negocio")[0];
                    
                    Modulo modulo = new Modulo();
                    modulo.Nome = "Negócio";
                    modulo.Tipo = "Negócio";

                    Tipo tipo = new Tipo();
                    tipo.Nome = "Regras de Negócio";
                    modulo.Tipos = new List<Tipo>();

                    ValorDado countNegocio = new ValorDado();

                    countNegocio.Nome = no_negocio.Attributes["Saida"].Value;
                    countNegocio.Multiplicador = Convert.ToInt32(no_negocio.Attributes["Multiplicador"].Value);

                    tipo.Valores = new List<ValorDado>();

                    if (!novo_ea)
                    {

                        foreach (Classe item in ea_negocio.classesEA)
                        {
                            if (item.nome_namespace.ToLower().IndexOf(AbaNegocio.ToLower()) >= 0)
                                countNegocio.Valor += item.metodos.Count;
                        }

                    }
                    else
                    {
                        // O novo modelo de EA obtem os totais de métodos da Presenter||Interface
                        if (modulos[1].Tipos[1].Nome.Equals("Presenter||Interface"))
                            countNegocio.Valor = modulos[1].Tipos[1].Valores[0].Valor + modulos[1].Tipos[1].Valores[1].Valor;
                        else
                            throw new ExceptionEA("Erro ao tentar atribuir no negócio os valores da presenter/interface no Negócio, Verifique o EA");
                    }

                    tipo.Valores.Add(countNegocio);

                    modulo.Tipos.Add(tipo);

                    modulos.Add(modulo);

                    ea_negocio.FecharEA();



                    if(DocumentoRTF != string.Empty)
                    {

                        int count_regras_rtf = 0;
                        ProcessarRTF(DocumentoRTF, ref count_regras_rtf);

                        XmlNode no_rtf = documento.GetElementsByTagName("Rtf")[0];

                        Modulo modulo_rtf = new Modulo();
                        modulo_rtf.Nome = "RTF";
                        modulo_rtf.Tipo = "RTF";

                        Tipo tipo_rtf = new Tipo();
                        tipo_rtf.Nome = "Casos de Testes";
                        modulo_rtf.Tipos = new List<Tipo>();

                        ValorDado countRTF = new ValorDado();

                        countRTF.Nome = no_rtf.Attributes["Saida"].Value;
                        countRTF.Multiplicador = Convert.ToInt32(no_rtf.Attributes["Multiplicador"].Value);
                        countRTF.Valor = count_regras_rtf;

                        tipo_rtf.Valores = new List<ValorDado>();

                        tipo_rtf.Valores.Add(countRTF);

                        modulo_rtf.Tipos.Add(tipo_rtf);

                        modulos.Add(modulo_rtf);
                    }



                    if(DocumentoXAML != string.Empty)
                    {
                        int count_bindings = 0;
                        int count_resourcekey = 0;
                        ProcessarXAML(DocumentoXAML, ref count_resourcekey, ref count_bindings);

                        XmlNode no_tela = documento.GetElementsByTagName("Xaml")[0];

                        Modulo modulo_tela = new Modulo();
                        modulo_tela.Nome = "Tela";
                        modulo_tela.Tipo = "Tela";

                        Tipo tipo_rtf = new Tipo();
                        tipo_rtf.Nome = "Recursos da Tela";
                        modulo_tela.Tipos = new List<Tipo>();

                        

                        tipo_rtf.Valores = new List<ValorDado>();
                        foreach(XmlNode no_interno in no_tela.ChildNodes)
                        {
                            ValorDado countXAML = new ValorDado();
                            countXAML.Nome = no_interno.Attributes["Saida"].Value;
                            countXAML.Multiplicador = Convert.ToInt32(no_interno.Attributes["Multiplicador"].Value);

                            if(no_interno.Name == "Count_ResourceKey")
                                countXAML.Valor = count_resourcekey;
                            else
                                countXAML.Valor = count_bindings;

                            tipo_rtf.Valores.Add(countXAML);
                        }



                        modulo_tela.Tipos.Add(tipo_rtf);

                        modulos.Add(modulo_tela);
                    }



                    int count_total = ProcessaTotal(modulos);


                    {

                        XmlNode no_rtf = documento.GetElementsByTagName("Leitura")[0];

                        if(no_rtf != null)
                        {

                            Modulo modulo_rtf = new Modulo();
                            modulo_rtf.Nome = "Leitura do EA";
                            modulo_rtf.Tipo = "Leitura do EA";

                            Tipo tipo_rtf = new Tipo();
                            tipo_rtf.Nome = "Leitura do EA";
                            modulo_rtf.Tipos = new List<Tipo>();

                            ValorDado countRTF = new ValorDado();

                            countRTF.Nome = no_rtf.Attributes["Saida"].Value;
                            countRTF.Multiplicador = count_total * 60 * Convert.ToInt32(no_rtf.Attributes["Multiplicador"].Value) / 100;
                            countRTF.Valor = 1;

                            tipo_rtf.Valores = new List<ValorDado>();

                            tipo_rtf.Valores.Add(countRTF);

                            modulo_rtf.Tipos.Add(tipo_rtf);

                            modulos.Add(modulo_rtf);
                        }
                    }

                    {

                        XmlNode no_rtf = documento.GetElementsByTagName("Correcoes")[0];

                        if(no_rtf != null)
                        {
                            Modulo modulo_rtf = new Modulo();
                            modulo_rtf.Nome = "Correções";
                            modulo_rtf.Tipo = "Correções";

                            Tipo tipo_rtf = new Tipo();
                            tipo_rtf.Nome = "Correções";
                            modulo_rtf.Tipos = new List<Tipo>();

                            ValorDado countRTF = new ValorDado();

                            countRTF.Nome = no_rtf.Attributes["Saida"].Value;
                            countRTF.Multiplicador = count_total * 60 * Convert.ToInt32(no_rtf.Attributes["Multiplicador"].Value) / 100;
                            countRTF.Valor = 1;

                            tipo_rtf.Valores = new List<ValorDado>();

                            tipo_rtf.Valores.Add(countRTF);

                            modulo_rtf.Tipos.Add(tipo_rtf);

                            modulos.Add(modulo_rtf);
                        }
                    }




                    //numero de bindings na tela

                }
                catch(Exception ex)
                {
                    throw new ExceptionEA("Erro ao tentar gerar as classes a partir do EA (Negocio)", ex);
                }


                return modulos;
            }
            catch(ExceptionEA exception)
            {
                string msg = "Erro ao geral na parte de Negócios";
                if (exception != null)
                    msg = exception.Message;
                throw new ExceptionEA(msg, exception);
            }
        }

        private static int ProcessaTotal(List<Modulo> modulos)
        {
            int total = 0;
            foreach(Modulo m in modulos)
                foreach(Tipo t in m.Tipos)
                    foreach(ValorDado v in t.Valores)
                        total += v.Multiplicador * v.Valor;

            double days = (total / 60) / 8;

            double horas_totais = Math.Ceiling(days) * 8;

            return Convert.ToInt32(horas_totais);
        }

        private static void ContarDadosQueryCondicional(ref int count_parametros_entradacondicional_ra, string query)
        {
            if(query.ToLower().IndexOf("se ") >= 0)
            {
                count_parametros_entradacondicional_ra += query.ToLower().Split(new string[] { "se " }, StringSplitOptions.RemoveEmptyEntries).Length - 1;
            }
        }

        private static void ContarDadosQuerySaida(ref int count_parametros_saida_ra, string query)
        {
            if(query.IndexOf(",") >= 0 && query.ToLower().IndexOf("select") >= 0)
                count_parametros_saida_ra += query.Split(',').Length;
        }

        private static void ContarDadosQueryEntrada(ref int count_parametros_entrada_ra, string query)
        {
            if(query.IndexOf(" :") >= 0)
            {
                count_parametros_entrada_ra += query.ToLower().Split(new string[] { " :" }, StringSplitOptions.RemoveEmptyEntries).Length - 1;
            }
            else if((query.IndexOf("=") >= 0) && query.ToLower().IndexOf("update ") >= 0)
            {
                count_parametros_entrada_ra += query.ToLower().Split(new string[] { "=" }, StringSplitOptions.RemoveEmptyEntries).Length - 1;
            }
            else if((query.IndexOf(",") >= 0) && query.ToLower().IndexOf("insert ") >= 0)
            {
                count_parametros_entrada_ra += (query.ToLower().Split(new string[] { "values" }, StringSplitOptions.RemoveEmptyEntries)[0].ToLower().Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries).Length);
            }


            if(query.ToLower().IndexOf("se ") >= 0)
            {
                int contador_temp = count_parametros_entrada_ra;
                //count_parametros_entradacondicional_ra += query.ToLower().Split(new string[] { "se " }, StringSplitOptions.RemoveEmptyEntries).Length - 1;
                count_parametros_entrada_ra -= 2 * (query.ToLower().Split(new string[] { "se " }, StringSplitOptions.RemoveEmptyEntries).Length - 1);
                if(count_parametros_entrada_ra < contador_temp)
                    count_parametros_entrada_ra = contador_temp;

            }
        }

        private static void ProcessarXAML(string arquivo, ref int countresourcekey, ref int countbinding)
        {
            try
            {
                StreamReader sr = File.OpenText(arquivo);
                string s = "";
                while((s = sr.ReadLine()) != null)
                {
                    if(s.ToLower().IndexOf("dynamicresource") >= 0 || s.ToLower().IndexOf("title") >= 0)
                        countresourcekey++;
                    if(VerificarComponentes(s.ToLower()))
                        countbinding++;

                }
            }
            catch(Exception ex)
            {
                throw new ExceptionEA("Erro ao abrir o arquivo de XAML", ex);
            }

        }
        private static bool VerificarComponentes(string line)
        {
            string[] controles = new string[] { "textbox", "checkbox", "datepicker", "column", "radio", "combobox" };

            foreach(string controle in controles)
            {
                if(line.IndexOf(controle) >= 0)
                    return true;
            }

            return false;
        }
        private static void ProcessarRTF(string arquivo, ref int countregras)
        {
            try
            {
                using(new ExcelUILanguageHelper())
                {

                    Microsoft.Office.Interop.Excel.Application _excelApp;

                    _excelApp = new Microsoft.Office.Interop.Excel.Application();

                    Workbook workBook = _excelApp.Workbooks.Open(arquivo,
                    Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                    Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                    Type.Missing, Type.Missing, Type.Missing, Type.Missing,
                    Type.Missing, Type.Missing);

                    //
                    // Pass the workbook to a separate function. This new function
                    // will iterate through the worksheets in the workbook.
                    //
                    ExcelScanIntenal(workBook, ref countregras);

                    //
                    // Clean up.
                    //
                    workBook.Close(false, arquivo, null);
                    Marshal.ReleaseComObject(workBook);
                }
            }
            catch(Exception ex)
            {
                throw new ExceptionEA("Erro ao abrir o arquivo de RTF", ex);
            }

        }

        private static void ExcelScanIntenal(Workbook workBookIn, ref int regras)
        {

            Worksheet sheet = (Worksheet)workBookIn.Sheets[3];


            Range excelRange = sheet.UsedRange;
            object[,] valueArray = (object[,])excelRange.get_Value(
                XlRangeValueDataType.xlRangeValueDefault);

            regras = Convert.ToInt32(valueArray[5, 2]);


        }

    }
}
